import { request } from './request'

// 生成题目
export const generateQuestions = (message,questionType,easy,medium,hard,provider,chatSession) => {
  return request.post(`/ai/generate?message=${message}&easy=${easy}&medium=${medium}&hard=${hard}&provider=${provider}&chatSession=${chatSession}`,  questionType ,{'Content-Type': 'application/json'})
}

// 生成知识图谱
export const generateGraphData = (graphRequest, provider) => {
  return request.post(`/ai/generate/graph?provider=${provider}`, graphRequest, {'Content-Type': 'application/json'})
}

// 发送聊天消息
export const sendChatMessage = (chatRequest, provider = 'deepseek') => {
  return request.post(`/ai/chat?provider=${provider}`, chatRequest)
}

// 简单消息发送
export const sendSimpleMessage = (message, provider = 'deepseek') => {
  return request.post(`/ai/send?message=${message}&provider=${provider}`)
}

// 上传文件解析
export const uploadFile = (file) => {
  const formData = new FormData()
  formData.append('file', file)
  return request.post('/ai/upload', formData, {
    headers: {
      'Content-Type': 'multipart/form-data'
    }
  })
}

// 流式生成知识图谱
export const generateGraphDataStream = (graphRequest, provider) => {
  return new Promise((resolve, reject) => {
    const baseUrl = import.meta.env.VITE_API_BASE_URL || '';
    
    // 创建一个URLSearchParams对象，用于携带provider参数
    const params = new URLSearchParams();
    params.append('provider', provider);
    
    // 创建请求URL
    const url = `${baseUrl}/ai/generate/graph/stream?${params.toString()}`;
    
    // 发送POST请求
    const xhr = new XMLHttpRequest();
    xhr.open('POST', url, true);
    xhr.setRequestHeader('Content-Type', 'application/json');
    xhr.responseType = 'text';
    xhr.timeout = 900000; // 15分钟超时
    
    // 用于保存事件流部分
    const graphData = [];
    let receivedData = '';
    let error = null;
    let isCompleted = false;
    
    // 最后一次接收数据的时间戳
    let lastDataTimestamp = Date.now();
    
    // 设置一个检查连接活跃度的定时器
    const activityChecker = setInterval(() => {
      const inactiveTime = Date.now() - lastDataTimestamp;
      // 如果30秒没有新数据，发送心跳保持连接
      if (inactiveTime > 30000) {
        console.log('30秒无活动，发送心跳检查');
        // 触发UI更新保持连接活跃
        if (window.dispatchEvent) {
          window.dispatchEvent(new Event('heartbeat'));
        }
      }
      
      // 如果3分钟没有新数据，认为连接可能已死亡
      if (inactiveTime > 180000) {
        console.warn('连接3分钟无活动，可能已断开');
        clearInterval(activityChecker);
        if (!isCompleted) {  // 只有在尚未完成的情况下才中止
          xhr.abort();
          reject(new Error('连接超时，长时间没有接收到数据'));
        }
      }
    }, 30000);  // 每30秒检查一次
    
    xhr.onprogress = function() {
      // 更新活跃时间戳
      lastDataTimestamp = Date.now();
      
      // 将新接收的数据添加到已接收数据中
      const newData = xhr.responseText.substring(receivedData.length);
      receivedData = xhr.responseText;
      
      // 解析事件流
      const lines = newData.split('\n');
      for (let i = 0; i < lines.length; i++) {
        const line = lines[i].trim();
        if (line.startsWith('data:')) {
          try {
            const eventData = line.substring(5).trim();
            
            // 心跳消息处理
            if (eventData === 'processing') {
              console.log('收到服务器心跳');
              continue;
            }
            
            // 检查是否是事件对象
            if (eventData.startsWith('{') && eventData.includes('"name"')) {
              const event = JSON.parse(eventData);
              if (event.name === 'data') {
                // 收到数据事件
                const data = Array.isArray(event.data) ? event.data : JSON.parse(event.data);
                
                // 对每个知识点进行处理
                if (Array.isArray(data)) {
                  // 将新的知识点添加到总数据集中
                  graphData.push(...data);
                  
                  // 触发UI更新（可选）
                  if (window.dispatchEvent) {
                    window.dispatchEvent(new CustomEvent('graph-data-update', {
                      detail: { newData: data, totalCount: graphData.length }
                    }));
                  }
                }
              } else if (event.name === 'error') {
                // 收到错误事件
                error = event.data;
                console.error('错误:', error);
              } else if (event.name === 'complete') {
                // 收到完成事件
                console.log('完成:', event.data);
                isCompleted = true;
                
                // 主动关闭连接
                clearInterval(activityChecker);
                resolve({
                  code: 200,
                  data: graphData,
                  message: event.data
                });
                
                // 尝试中断XHR
                try {
                  xhr.abort();
                } catch (e) {
                  console.log('结束时中断XHR失败', e);
                }
              } else if (event.name === 'progress') {
                // 收到进度事件
                console.log('进度:', event.data);
                
                // 触发UI进度更新
                if (window.dispatchEvent) {
                  window.dispatchEvent(new CustomEvent('graph-data-progress', {
                    detail: { message: event.data }
                  }));
                }
              } else if (event.name === 'heartbeat') {
                // 收到心跳事件
                console.log('心跳:', event.data);
                lastDataTimestamp = Date.now(); // 刷新时间戳
              } else if (event.name === 'warning') {
                // 收到警告事件
                console.warn('警告:', event.data);
              }
            }
          } catch (e) {
            console.error('解析事件数据失败:', e, line);
          }
        }
      }
    };
    
    xhr.onload = function() {
      clearInterval(activityChecker);
      if (!isCompleted) {  // 只有在尚未完成的情况下才处理
        if (xhr.status === 200) {
          if (error) {
            reject(new Error(error));
          } else {
            resolve({
              code: 200,
              data: graphData,
              message: '知识图谱生成完成'
            });
          }
        } else {
          reject(new Error(`请求失败: ${xhr.status} ${xhr.statusText}`));
        }
      }
    };
    
    xhr.ontimeout = function() {
      clearInterval(activityChecker);
      if (!isCompleted) {
        reject(new Error('请求超时'));
      }
    };
    
    xhr.onerror = function() {
      clearInterval(activityChecker);
      if (!isCompleted) {
        reject(new Error('网络请求失败'));
      }
    };
    
    xhr.onabort = function() {
      clearInterval(activityChecker);
      if (!isCompleted) {
        reject(new Error('请求被中止'));
      }
    };
    
    // 发送请求体
    xhr.send(JSON.stringify(graphRequest));
  });
};

